/**
 * 分析结果持久化服务
 * 负责保存、加载、管理分析结果
 */

class AnalysisResultService {
    /**
     * 保存分析结果
     * @param {string} caseId 案件ID
     * @param {string} subjectId 人员ID（null表示全量模式）
     * @param {Object} results 分析结果对象
     * @returns {Promise<boolean>} 是否成功
     */
    static async saveResult(caseId, subjectId, results) {
        try {
            const key = this.generateKey(caseId, subjectId);
            const resultData = {
                caseId,
                subjectId,
                subjectName: results.subjectName || null,
                results,
                createdAt: new Date().toISOString(),
                version: '1.0'
            };

            // 使用 localStorage 存储（简单实现）
            // 生产环境应该存储到数据库
            localStorage.setItem(key, JSON.stringify(resultData));

            console.log(`[AnalysisResultService] 保存成功: ${key}`);
            return true;
        } catch (error) {
            console.error('[AnalysisResultService] 保存失败:', error);
            return false;
        }
    }

    /**
     * 加载分析结果
     * @param {string} caseId 案件ID
     * @param {string} subjectId 人员ID（null表示全量模式）
     * @returns {Promise<Object|null>} 分析结果或null
     */
    static async loadResult(caseId, subjectId) {
        try {
            const key = this.generateKey(caseId, subjectId);
            const data = localStorage.getItem(key);

            if (!data) {
                console.log(`[AnalysisResultService] 未找到缓存结果: ${key}`);
                return null;
            }

            const resultData = JSON.parse(data);
            console.log(`[AnalysisResultService] 加载成功: ${key}`, resultData.createdAt);
            return resultData;
        } catch (error) {
            console.error('[AnalysisResultService] 加载失败:', error);
            return null;
        }
    }

    /**
     * 删除分析结果
     * @param {string} caseId 案件ID
     * @param {string} subjectId 人员ID（null表示全量模式）
     */
    static async deleteResult(caseId, subjectId) {
        const key = this.generateKey(caseId, subjectId);
        localStorage.removeItem(key);
        console.log(`[AnalysisResultService] 删除结果: ${key}`);
    }

    /**
     * 清空案件的所有分析结果
     * @param {string} caseId 案件ID
     */
    static async clearCaseResults(caseId) {
        const prefix = `analysis_result_${caseId}_`;
        const keysToDelete = [];

        for (let i = 0; i < localStorage.length; i++) {
            const key = localStorage.key(i);
            if (key && key.startsWith(prefix)) {
                keysToDelete.push(key);
            }
        }

        keysToDelete.forEach(key => localStorage.removeItem(key));
        console.log(`[AnalysisResultService] 清空案件 ${caseId} 的 ${keysToDelete.length} 个分析结果`);
    }

    /**
     * 生成存储键
     */
    static generateKey(caseId, subjectId) {
        const subjectPart = subjectId || 'global';
        return `analysis_result_${caseId}_${subjectPart}`;
    }

    /**
     * 检查是否有缓存结果
     */
    static async hasResult(caseId, subjectId) {
        const key = this.generateKey(caseId, subjectId);
        return localStorage.getItem(key) !== null;
    }

    /**
     * 获取分析时间
     */
    static async getResultTime(caseId, subjectId) {
        const result = await this.loadResult(caseId, subjectId);
        return result ? result.createdAt : null;
    }
}

// 暴露到全局
window.AnalysisResultService = AnalysisResultService;
